// utils/storage.js

/**
 * 统一存储封装
 * 支持永久缓存和带过期时间的临时缓存
 */
const storage = {
	// ================== 基础方法 ==================

	/**
	 * 设置缓存
	 * @param {string} key 缓存键
	 * @param {any} value 缓存值
	 * @param {number} expire 过期时间(秒)，0表示永久缓存
	 * @return {boolean} 是否设置成功
	 */
	set(key, value, expire = 0) {
		try {
			const data = {
				value, // 存储值
				time: Date.now(), // 存储时间
				expire: expire > 0 ? Date.now() + expire * 1000 : 0 // 过期时间
			}
			uni.setStorageSync(key, JSON.stringify(data))
			return true
		} catch (e) {
			console.error(`storage.set error for key "${key}":`, e)
			return false
		}
	},

	/**
	 * 获取缓存
	 * @param {string} key 缓存键
	 * @param {any} defaultValue 默认值
	 * @return {any} 缓存值或默认值
	 */
	get(key, defaultValue = null) {
		try {
			const dataStr = uni.getStorageSync(key)
			if (!dataStr) return defaultValue

			const data = JSON.parse(dataStr)

			// 检查是否过期
			if (data.expire > 0 && Date.now() > data.expire) {
				this.remove(key) // 过期自动清理
				return defaultValue
			}

			return data.value
		} catch (e) {
			console.error(`storage.get error for key "${key}":`, e)
			return defaultValue
		}
	},

	/**
	 * 移除缓存
	 * @param {string} key 缓存键
	 * @return {boolean} 是否移除成功
	 */
	remove(key) {
		try {
			uni.removeStorageSync(key)
			return true
		} catch (e) {
			console.error(`storage.remove error for key "${key}":`, e)
			return false
		}
	},

	/**
	 * 清空所有缓存
	 * @return {boolean} 是否清空成功
	 */
	clear() {
		try {
			uni.clearStorageSync()
			return true
		} catch (e) {
			console.error('storage.clear error:', e)
			return false
		}
	},

	// ================== 高级方法 ==================

	/**
	 * 设置永久缓存
	 * @param {string} key 缓存键
	 * @param {any} value 缓存值
	 * @return {boolean} 是否设置成功
	 */
	setForever(key, value) {
		return this.set(key, value, 0)
	},

	/**
	 * 设置临时缓存（带过期时间）
	 * @param {string} key 缓存键
	 * @param {any} value 缓存值
	 * @param {number} seconds 过期时间(秒)
	 * @return {boolean} 是否设置成功
	 */
	setTemp(key, value, seconds) {
		if (!seconds || seconds <= 0) {
			console.warn('storage.setTemp: seconds should be positive number')
			return false
		}
		return this.set(key, value, seconds)
	},

	/**
	 * 更新缓存值（不改变过期时间）
	 * @param {string} key 缓存键
	 * @param {any} newValue 新值
	 * @return {boolean} 是否更新成功
	 */
	update(key, newValue) {
		try {
			const dataStr = uni.getStorageSync(key)
			if (!dataStr) return false

			const oldData = JSON.parse(dataStr)
			const newData = {
				value: newValue,
				time: Date.now(), // 更新时间
				expire: oldData.expire // 保持原过期时间
			}

			uni.setStorageSync(key, JSON.stringify(newData))
			return true
		} catch (e) {
			console.error(`storage.update error for key "${key}":`, e)
			return false
		}
	},

	/**
	 * 更新缓存过期时间
	 * @param {string} key 缓存键
	 * @param {number} seconds 新的过期时间(秒)
	 * @return {boolean} 是否更新成功
	 */
	updateExpire(key, seconds) {
		try {
			const dataStr = uni.getStorageSync(key)
			if (!dataStr) return false

			const oldData = JSON.parse(dataStr)
			const newData = {
				value: oldData.value,
				time: oldData.time, // 保持原存储时间
				expire: seconds > 0 ? Date.now() + seconds * 1000 : 0
			}

			uni.setStorageSync(key, JSON.stringify(newData))
			return true
		} catch (e) {
			console.error(`storage.updateExpire error for key "${key}":`, e)
			return false
		}
	},

	/**
	 * 获取缓存剩余时间(秒)
	 * @param {string} key 缓存键
	 * @return {number} 剩余时间(秒)，-1表示永久，-2表示不存在或已过期
	 */
	getRemainingTime(key) {
		try {
			const dataStr = uni.getStorageSync(key)
			if (!dataStr) return -2

			const data = JSON.parse(dataStr)
			if (data.expire === 0) return -1 // 永久缓存

			const remaining = (data.expire - Date.now()) / 1000
			return remaining > 0 ? Math.ceil(remaining) : -2
		} catch (e) {
			console.error(`storage.getRemainingTime error for key "${key}":`, e)
			return -2
		}
	},

	/**
	 * 检查缓存是否存在且未过期
	 * @param {string} key 缓存键
	 * @return {boolean} 是否存在且有效
	 */
	has(key) {
		return this.getRemainingTime(key) >= 0
	},

	/**
	 * 获取所有缓存键
	 * @return {string[]} 所有缓存键数组
	 */
	keys() {
		try {
			const {
				keys
			} = uni.getStorageInfoSync()
			return keys
		} catch (e) {
			console.error('storage.keys error:', e)
			return []
		}
	}
}

export default storage